﻿using System;
using System.Collections.Generic;
using System.Text;
using System.Reflection;
using System.Collections;

namespace lxwmvc
{
    /// <summary>
    /// 匿名类帮助
    /// </summary>
    public class objecthelper
    {
        /// <summary>
        /// 匿名类转换
        /// var a = castanonymous(anonymous, new { a=0, Name = "", b = false });
        /// var c = new { a = new Func【 string,DialogResult】 (MessageBox.Show), b = 2 };
        /// </summary>
        /// <typeparam name="lxw"></typeparam>
        /// <param name="anonymous"></param>
        /// <param name="anonymousType"></param>
        /// <returns></returns>
        public static lxw castanonymous<lxw>(object anonymous, lxw anonymousType)
        {
            return (lxw)anonymous;
        }

        /// <summary>
        /// 这是一个自己调用直接无返回值，递归委托函数
        /// </summary>
        /// <typeparam name="T">参数1</typeparam>
        /// <typeparam name="T1">参数2</typeparam>
        /// <param name="f">自己</param>
        /// <returns></returns>
        public static Action<T, T1> Fix<T, T1>(Func<Action<T, T1>, Action<T, T1>> f)
        {
            return (x, y) => f(Fix(f))(x, y);
        }

        /// <summary>
        /// 这是一个递归的委托函数
        /// </summary>
        /// <typeparam name="T">参数1</typeparam>
        /// <typeparam name="T1">返回值</typeparam>
        /// <param name="f">自己</param>
        /// <returns></returns>
        public static Func<T, T1> FixF<T, T1>(Func<Func<T, T1>, Func<T, T1>> f)
        {
            return (x) => f(FixF(f))(x);
        }

        ///// <summary>
        ///// 复制对象
        ///// </summary>
        ///// <param name="obj"></param>
        ///// <returns></returns>
        //public static object clone(object obj)
        //{
        //    //首先我们建立指定类型的一个实例
        //    object newObject = Activator.CreateInstance(obj.GetType());
        //    //我们取得新的类型实例的字段数组。
        //    FieldInfo[] fields = newObject.GetType().GetFields();
        //    int i = 0;
        //    foreach (FieldInfo fi in obj.GetType().GetFields())
        //    {
        //        //我们判断字段是否支持ICloneable接口。
        //        Type ICloneType = fi.FieldType.GetInterface("ICloneable", true);
        //        if (ICloneType != null)
        //        {
        //            //取得对象的Icloneable接口。
        //            ICloneable IClone = (ICloneable)fi.GetValue(obj);
        //            //我们使用克隆方法给字段设定新值。
        //            fields[i].SetValue(newObject, IClone.Clone());
        //        }
        //        else
        //        {
        //            // 如果该字段部支持Icloneable接口，直接设置即可。
        //            fields[i].SetValue(newObject, fi.GetValue(obj));
        //        }
        //        //现在我们检查该对象是否支持IEnumerable接口，如果支持，
        //        //我们还需要枚举其所有项并检查他们是否支持IList 或 IDictionary 接口。
        //        Type IEnumerableType = fi.FieldType.GetInterface("IEnumerable", true);
        //        if (IEnumerableType != null)
        //        {
        //            //取得该字段的IEnumerable接口
        //            IEnumerable IEnum = (IEnumerable)fi.GetValue(obj);
        //            Type IListType = fields[i].FieldType.GetInterface("IList", true);
        //            Type IDicType = fields[i].FieldType.GetInterface("IDictionary", true);
        //            int j = 0;
        //            if (IListType != null)
        //            {
        //                //取得IList接口。
        //                IList list = (IList)fields[i].GetValue(newObject);
        //                foreach (object o in IEnum)
        //                {
        //                    //查看当前项是否支持支持ICloneable 接口。
        //                    ICloneType = o.GetType().GetInterface("ICloneable", true);
        //                    if (ICloneType != null)
        //                    {
        //                        //如果支持ICloneable 接口，
        //                        //我们用它李设置列表中的对象的克隆
        //                        ICloneable clone = (ICloneable)o;
        //                        list[j] = clone.Clone();
        //                    }
        //                    //注意：如果列表中的项不支持ICloneable接口，那么
        //                    //在克隆列表的项将与原列表对应项相同
        //                    //（只要该类型是引用类型）
        //                    j++;
        //                }
        //            }
        //            else if (IDicType != null)
        //            {
        //                //取得IDictionary 接口
        //                IDictionary dic = (IDictionary)fields[i].GetValue(newObject);
        //                j = 0;
        //                foreach (DictionaryEntry de in IEnum)
        //                {
        //                    //查看当前项是否支持支持ICloneable 接口。
        //                    ICloneType = de.Value.GetType().
        //                    GetInterface("ICloneable", true);
        //                    if (ICloneType != null)
        //                    {
        //                        ICloneable clone = (ICloneable)de.Value;
        //                        dic[de.Key] = clone.Clone();
        //                    }
        //                    j++;
        //                }
        //            }
        //        }
        //        i++;
        //    }
        //    return newObject;
        //}

    }
}